from flask import Blueprint, request, jsonify, current_app
from flask_jwt_extended import jwt_required, get_jwt_identity
from flasgger import swag_from
from sqlalchemy import or_
from app import db
from app.models import User, UserAttribute, UserRelation, Activity, ActivityParticipant
from app.utils.response import success_response, error_response
from app.utils.decorators import permission_required, admin_required

user_management_bp = Blueprint('admin_user_management', __name__)

@user_management_bp.route('/users', methods=['GET'])
@jwt_required()
@permission_required('user:read')
@swag_from({
    'tags': ['用户管理'],
    'summary': '获取用户列表',
    'description': '管理员获取用户列表，支持分页和筛选',
    'parameters': [
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码，从1开始'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量，最大100'
        },
        {
            'name': 'keyword',
            'in': 'query',
            'type': 'string',
            'description': '搜索关键词（昵称或手机号）'
        },
        {
            'name': 'is_active',
            'in': 'query',
            'type': 'boolean',
            'description': '用户状态筛选：true=活跃，false=禁用'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'users': {
                                'type': 'array',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'nickname': {'type': 'string'},
                                        'phone': {'type': 'string'},
                                        'avatar_url': {'type': 'string'},
                                        'gender': {'type': 'integer'},
                                        'is_active': {'type': 'boolean'},
                                        'created_at': {'type': 'string'}
                                    }
                                }
                            },
                            'total': {'type': 'integer'},
                            'page': {'type': 'integer'},
                            'pages': {'type': 'integer'},
                            'per_page': {'type': 'integer'}
                        }
                    }
                }
            }
        }
    }
})
def get_users():
    """获取用户列表"""
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 100)
        keyword = request.args.get('keyword', '').strip()
        is_active = request.args.get('is_active', type=bool)
        
        # 构建查询
        query = User.query
        
        # 关键词搜索
        if keyword:
            query = query.filter(
                or_(
                    User.nickname.contains(keyword),
                    User.phone.contains(keyword)
                )
            )
        
        # 状态筛选
        if is_active is not None:
            query = query.filter(User.is_active == is_active)
        
        # 排序
        query = query.order_by(User.created_at.desc())
        
        # 分页
        pagination = query.paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        users = []
        for user in pagination.items:
            user_data = user.to_dict()
            # 添加统计信息
            user_data['orders_count'] = user.orders.count()
            users.append(user_data)
        
        return success_response({
            'users': users,
            'total': pagination.total,
            'page': page,
            'pages': pagination.pages,
            'per_page': per_page
        }, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取用户列表失败: {str(e)}")
        return error_response('获取失败', 500)

@user_management_bp.route('/users/<int:user_id>', methods=['GET'])
@jwt_required()
@permission_required('user:read')
@swag_from({
    'tags': ['用户管理'],
    'summary': '获取用户详情',
    'description': '管理员获取用户详细信息，包括用户属性和关系',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'user': {'type': 'object', 'description': '用户基本信息'},
                            'attributes': {'type': 'object', 'description': '用户自定义属性'},
                            'relations': {
                                'type': 'object',
                                'properties': {
                                    'friends': {'type': 'array', 'description': '好友列表'},
                                    'blacklist': {'type': 'array', 'description': '黑名单列表'}
                                }
                            },
                            'statistics': {
                                'type': 'object',
                                'properties': {
                                    'orders_count': {'type': 'integer', 'description': '订单数量'},
                                    'activities_count': {'type': 'integer', 'description': '参与活动数量'}
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def get_user_detail(user_id):
    """获取用户详情"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        # 获取用户基本信息
        user_data = user.to_dict()
        
        # 获取用户属性
        attributes = UserAttribute.get_user_attributes(user_id)
        
        # 获取用户关系
        friends = UserRelation.query.filter_by(
            owner_id=user_id,
            relation_type='friend'
        ).all()
        blacklist = UserRelation.query.filter_by(
            owner_id=user_id,
            relation_type='blacklist'
        ).all()
        
        relations = {
            'friends': [rel.to_dict(include_users=True) for rel in friends],
            'blacklist': [rel.to_dict(include_users=True) for rel in blacklist]
        }
        
        # 统计信息
        statistics = {
            'orders_count': user.orders.count(),
            'activities_count': ActivityParticipant.query.filter_by(user_id=user_id, status='joined').count()
        }
        
        return success_response({
            'user': user_data,
            'attributes': attributes,
            'relations': relations,
            'statistics': statistics
        }, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取用户详情失败: {str(e)}")
        return error_response('获取失败', 500)

@user_management_bp.route('/users/<int:user_id>', methods=['PUT'])
@jwt_required()
@permission_required('user:update')
@swag_from({
    'tags': ['用户管理'],
    'summary': '更新用户信息',
    'description': '管理员更新用户基本信息和自定义属性',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'nickname': {'type': 'string', 'description': '昵称'},
                    'phone': {'type': 'string', 'description': '手机号'},
                    'gender': {'type': 'integer', 'enum': [0, 1, 2], 'description': '性别：0=未知，1=男，2=女'},
                    'is_active': {'type': 'boolean', 'description': '是否活跃'},
                    'avatar_url': {'type': 'string', 'description': '头像URL'},
                    'attributes': {'type': 'object', 'description': '用户自定义属性（键值对）'}
                },
                'example': {
                    'nickname': '新昵称',
                    'is_active': True,
                    'attributes': {
                        'vip_level': '黄金会员',
                        'prefer_sport': '篮球'
                    }
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '更新成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '更新成功'},
                    'data': {
                        'type': 'object',
                        'description': '更新后的数据'
                    }
                }
            }
        }
    }
})
def update_user(user_id):
    """更新用户信息"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        data = request.get_json()
        
        # 更新用户基本信息
        if 'nickname' in data:
            user.nickname = data['nickname']
        if 'phone' in data:
            # 检查手机号是否已存在
            existing_user = User.query.filter(
                User.phone == data['phone'],
                User.id != user_id
            ).first()
            if existing_user:
                return error_response('手机号已被其他用户使用')
            user.phone = data['phone']
        if 'gender' in data:
            user.gender = data['gender']
        if 'is_active' in data:
            user.is_active = data['is_active']
        if 'avatar_url' in data:
            user.avatar_url = data['avatar_url']
        
        # 更新用户属性
        if 'attributes' in data and isinstance(data['attributes'], dict):
            UserAttribute.batch_set_attributes(user_id, data['attributes'])
        
        db.session.commit()
        
        return success_response(user.to_dict(), '用户信息更新成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"更新用户信息失败: {str(e)}")
        return error_response('更新失败', 500)

@user_management_bp.route('/users/<int:user_id>', methods=['DELETE'])
@jwt_required()
@permission_required('user:delete')
@swag_from({
    'tags': ['用户管理'],
    'summary': '删除/禁用用户',
    'description': '管理员禁用用户账户（软删除）',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        }
    ],
    'responses': {
        200: {
            'description': '禁用成功'
        }
    }
})
def delete_user(user_id):
    """删除/禁用用户"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        # 软删除：标记为非活跃状态
        user.is_active = False
        db.session.commit()
        
        return success_response(None, '用户已被禁用')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"禁用用户失败: {str(e)}")
        return error_response('禁用失败', 500)

@user_management_bp.route('/users/batch_delete', methods=['POST'])
@jwt_required()
@permission_required('user:delete')
@swag_from({
    'tags': ['用户管理'],
    'summary': '批量删除/禁用用户',
    'description': '管理员批量禁用用户账户（软删除）',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['ids'],
                'properties': {
                    'ids': {
                        'type': 'array',
                        'items': {'type': 'integer'},
                        'description': '要禁用的用户ID列表'
                    }
                },
                'example': {
                    'ids': [1, 2, 3]
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '批量禁用成功'
        },
        400: {
            'description': '请求参数错误'
        }
    }
})
def batch_delete_users():
    """批量删除/禁用用户"""
    try:
        data = request.get_json()
        user_ids = data.get('ids')

        if not user_ids or not isinstance(user_ids, list):
            return error_response('无效的ID列表', 400)

        # 批量更新用户状态为非活跃
        users_to_disable = User.query.filter(User.id.in_(user_ids)).all()
        
        if not users_to_disable:
            return error_response('未找到任何有效用户', 404)

        disabled_count = 0
        for user in users_to_disable:
            user.is_active = False
            disabled_count += 1
        
        db.session.commit()
        
        return success_response(None, f'成功禁用 {disabled_count} 个用户')

    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"批量禁用用户失败: {str(e)}")
        return error_response('批量禁用失败', 500)

@user_management_bp.route('/users/<int:user_id>/attributes', methods=['POST'])
@jwt_required()
@permission_required('user:manage_attributes')
@swag_from({
    'tags': ['用户管理'],
    'summary': '添加用户属性',
    'description': '管理员为用户添加自定义属性',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['key', 'value'],
                'properties': {
                    'key': {'type': 'string', 'description': '属性键名'},
                    'value': {'type': 'string', 'description': '属性值'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '添加成功'
        }
    }
})
def add_user_attribute(user_id):
    """添加用户属性"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        data = request.get_json()
        key = data.get('key')
        value = data.get('value')
        
        if not key:
            return error_response('属性键名不能为空')
        
        attribute = UserAttribute.set_user_attribute(user_id, key, value)
        db.session.commit()
        
        return success_response(attribute.to_dict() if attribute else None, '属性添加成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"添加用户属性失败: {str(e)}")
        return error_response('添加失败', 500)

@user_management_bp.route('/users/<int:user_id>/attributes/<string:key>', methods=['DELETE'])
@jwt_required()
@permission_required('user:manage_attributes')
@swag_from({
    'tags': ['用户管理'],
    'summary': '删除用户属性',
    'description': '管理员删除用户的指定属性',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'key',
            'in': 'path',
            'type': 'string',
            'required': True,
            'description': '属性键名'
        }
    ],
    'responses': {
        200: {
            'description': '删除用户属性成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '删除成功'}
                }
            }
        }
    }
})
def delete_user_attribute(user_id, key):
    """删除用户属性"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        success = UserAttribute.delete_user_attribute(user_id, key)
        if success:
            db.session.commit()
            return success_response(None, '属性删除成功')
        else:
            return error_response('属性不存在', 404)
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"删除用户属性失败: {str(e)}")
        return error_response('删除失败', 500)

@user_management_bp.route('/users/<int:user_id>/relations', methods=['POST'])
@jwt_required()
@permission_required('user:manage_relations')
@swag_from({
    'tags': ['用户管理'],
    'summary': '添加用户关系',
    'description': '管理员为用户添加好友或黑名单关系',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['relation_type', 'target_id'],
                'properties': {
                    'relation_type': {'type': 'string', 'description': '关系类型', 'enum': ['friend', 'blacklist']},
                    'target_id': {'type': 'integer', 'description': '目标用户ID'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '添加成功'
        }
    }
})
def add_user_relation(user_id):
    """添加用户关系"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        data = request.get_json()
        relation_type = data.get('relation_type')
        target_id = data.get('target_id')
        
        if not relation_type or not target_id:
            return error_response('关系类型和目标用户ID不能为空')
        
        relation = UserRelation.set_relation(user_id, target_id, relation_type)
        db.session.commit()
        
        return success_response(relation.to_dict() if relation else None, '关系添加成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"添加用户关系失败: {str(e)}")
        return error_response('添加失败', 500)

@user_management_bp.route('/users/<int:user_id>/relations', methods=['DELETE'])
@jwt_required()
@permission_required('user:manage_relations')
@swag_from({
    'tags': ['用户管理'],
    'summary': '删除用户关系',
    'description': '管理员删除用户的指定关系',
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'relation_type',
            'in': 'path',
            'type': 'string',
            'required': True,
            'description': '关系类型',
            'enum': ['friend', 'blacklist']
        },
        {
            'name': 'target_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '目标用户ID'
        }
    ],
    'responses': {
        200: {
            'description': '删除用户属性成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '删除成功'}
                }
            }
        }
    }
})
def delete_user_relation(user_id, relation_type, target_id):
    """删除用户关系"""
    try:
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        success = UserRelation.delete_user_relation(user_id, relation_type, target_id)
        if success:
            db.session.commit()
            return success_response(None, '关系删除成功')
        else:
            return error_response('关系不存在', 404)
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"删除用户关系失败: {str(e)}")
        return error_response('删除失败', 500)

@user_management_bp.route('/users/<int:user_id>/activities', methods=['GET'])
@admin_required
@swag_from({
    'tags': ['用户管理'],
    'summary': '获取用户活动记录',
    'description': '管理员获取指定用户的活动参与记录',
    'security': [{'Bearer': []}],
    'parameters': [
        {
            'name': 'user_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '用户ID'
        },
        {
            'name': 'page',
            'in': 'query',
            'type': 'integer',
            'default': 1,
            'description': '页码'
        },
        {
            'name': 'per_page',
            'in': 'query',
            'type': 'integer',
            'default': 10,
            'description': '每页数量'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '获取成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'activities': {
                                'type': 'array',
                                'items': {'type': 'object'}
                            },
                            'total': {'type': 'integer'},
                            'page': {'type': 'integer'},
                            'pages': {'type': 'integer'}
                        }
                    }
                }
            }
        },
        404: {
            'description': '用户不存在'
        }
    }
})
def get_user_activities(user_id):
    """获取用户活动记录"""
    try:
        # 检查用户是否存在
        user = User.query.get(user_id)
        if not user:
            return error_response('用户不存在', 404)
        
        page = request.args.get('page', 1, type=int)
        per_page = min(request.args.get('per_page', 10, type=int), 50)
        
        # 获取用户组织的活动
        organized_activities = Activity.query.filter_by(
            organizer_id=user_id,
            is_active=True
        ).all()
        
        # 获取用户参与的活动
        participated_query = db.session.query(Activity, ActivityParticipant).join(
            ActivityParticipant, Activity.id == ActivityParticipant.activity_id
        ).filter(
            ActivityParticipant.user_id == user_id,
            Activity.is_active == True
        )
        
        participated_activities = participated_query.all()
        
        # 合并活动列表
        all_activities = []
        
        # 添加组织的活动
        for activity in organized_activities:
            activity_data = activity.to_dict(include_venue=True, include_participants=True)
            activity_data['user_role'] = 'organizer'
            activity_data['creator_id'] = activity.organizer_id  # 兼容前端字段名
            all_activities.append(activity_data)
        
        # 添加参与的活动
        for activity, participant in participated_activities:
            if activity.organizer_id != user_id:  # 避免重复
                activity_data = activity.to_dict(include_venue=True, include_participants=True)
                activity_data['user_role'] = 'participant'
                activity_data['creator_id'] = activity.organizer_id  # 兼容前端字段名
                activity_data['participation_status'] = participant.status
                activity_data['joined_at'] = participant.joined_at.strftime('%Y-%m-%d %H:%M:%S') if participant.joined_at else None
                all_activities.append(activity_data)
        
        # 按创建时间排序
        all_activities.sort(key=lambda x: x.get('created_at', ''), reverse=True)
        
        # 手动分页
        total = len(all_activities)
        start = (page - 1) * per_page
        end = start + per_page
        activities_page = all_activities[start:end]
        
        return success_response({
            'activities': activities_page,
            'total': total,
            'page': page,
            'pages': (total + per_page - 1) // per_page
        }, '获取成功')
        
    except Exception as e:
        current_app.logger.error(f"获取用户活动记录失败: {str(e)}")
        return error_response('获取失败', 500)

@user_management_bp.route('/relations', methods=['POST'])
@jwt_required()
@permission_required('user:manage_relations')
@swag_from({
    'tags': ['用户管理'],
    'summary': '创建用户关系',
    'description': '管理员创建用户关系（好友或黑名单）',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['user_id', 'target_user_id', 'relation_type'],
                'properties': {
                    'user_id': {'type': 'integer', 'description': '用户ID'},
                    'target_user_id': {'type': 'integer', 'description': '目标用户ID'},
                    'relation_type': {'type': 'string', 'description': '关系类型', 'enum': ['friend', 'blacklist']}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '创建成功'
        }
    }
})
def create_user_relation():
    """创建用户关系"""
    try:
        data = request.get_json()
        user_id = data.get('user_id')
        target_user_id = data.get('target_user_id')
        relation_type = data.get('relation_type')
        
        if not user_id or not target_user_id or not relation_type:
            return error_response('用户ID、目标用户ID和关系类型不能为空')
        
        # 检查用户是否存在
        user = User.query.get(user_id)
        target_user = User.query.get(target_user_id)
        
        if not user:
            return error_response('用户不存在', 404)
        if not target_user:
            return error_response('目标用户不存在', 404)
        
        # 检查是否已存在相同关系
        existing_relation = UserRelation.query.filter_by(
            owner_id=user_id,
            target_id=target_user_id,
            relation_type=relation_type
        ).first()
        
        if existing_relation:
            return error_response('该关系已存在')
        
        relation = UserRelation.set_relation(user_id, target_user_id, relation_type)
        db.session.commit()
        
        return success_response(relation.to_dict() if relation else None, '关系创建成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"创建用户关系失败: {str(e)}")
        return error_response('创建失败', 500)

@user_management_bp.route('/relations/<int:relation_id>', methods=['PUT'])
@jwt_required()
@permission_required('user:manage_relations')
@swag_from({
    'tags': ['用户管理'],
    'summary': '更新用户关系',
    'description': '管理员更新用户关系类型',
    'parameters': [
        {
            'name': 'relation_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '关系ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'relation_type': {'type': 'string', 'description': '关系类型', 'enum': ['friend', 'blacklist']}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '更新成功'
        }
    }
})
def update_user_relation(relation_id):
    """更新用户关系"""
    try:
        relation = UserRelation.query.get(relation_id)
        if not relation:
            return error_response('关系不存在', 404)
        
        data = request.get_json()
        relation_type = data.get('relation_type')
        
        if relation_type:
            relation.relation_type = relation_type
        
        db.session.commit()
        
        return success_response(relation.to_dict(), '关系更新成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"更新用户关系失败: {str(e)}")
        return error_response('更新失败', 500)

@user_management_bp.route('/relations/<int:relation_id>', methods=['DELETE'])
@jwt_required()
@permission_required('user:manage_relations')
@swag_from({
    'tags': ['用户管理'],
    'summary': '删除用户关系',
    'description': '管理员删除用户关系',
    'parameters': [
        {
            'name': 'relation_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '关系ID'
        }
    ],
    'responses': {
        200: {
            'description': '删除成功'
        }
    }
})
def delete_user_relation_by_id(relation_id):
    """根据ID删除用户关系"""
    try:
        relation = UserRelation.query.get(relation_id)
        if not relation:
            return error_response('关系不存在', 404)
        
        db.session.delete(relation)
        db.session.commit()
        
        return success_response(None, '关系删除成功')
        
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"删除用户关系失败: {str(e)}")
        return error_response('删除失败', 500) 